Efficient and Effective Handling of Exceptions in Java Points-To Analysis

A joint points-to and exception analysis has been shown to yield benefits in both precision and performance. Treating exceptions as regular objects, however, incurs significant and rather unexpected overhead. We show that in a typical joint analysis most of the objects computed to flow in and out of a method are due to exceptional control-flow and not normal call-return control-flow. For instance, a context-insensitive analysis of the Antlr benchmark from the DaCapo suite computes 4-5 times more objects going in or out of a method due to exceptional control-flow than due to normal control-flow. As a consequence, the analysis spends a large amount of its time considering exceptions. We show that the problem can be addressed both e ectively and elegantly by coarsening the representation of exception objects. An interesting find is that, instead of recording each distinct exception object, we can collapse all exceptions of the same type, and use one representative object per type, to yield nearly identical precision (loss of less than 0.1%) but with a boost in performance of at least 50% for most analyses and benchmarks and large space savings (usually 40% or more)

Set-Based Pre-Processing for Points-To Analysis

We present set-based pre-analysis: a virtually universal op- timization technique for flow-insensitive points-to analysis. Points-to analysis computes a static abstraction of how ob- ject values flow through a program’s variables. Set-based pre-analysis relies on the observation that much of this rea- soning can take place at the set level rather than the value level. Computing constraints at the set level results in sig- nificant optimization opportunities: we can rewrite the in- put program into a simplified form with the same essential points-to properties. This rewrite results in removing both local variables and instructions, thus simplifying the sub- sequent value-based points-to computation. E ectively, set- based pre-analysis puts the program in a normal form opti- mized for points-to analysis. Compared to other techniques for o -line optimization of points-to analyses in the literature, the new elements of our approach are the ability to eliminate statements, and not just variables, as well as its modularity: set-based pre-analysis can be performed on the input just once, e.g., allowing the pre-optimization of libraries that are subsequently reused many times and for di erent analyses. In experiments with Java programs, set-based pre-analysis eliminates 30% of the program’s local variables and 30% or more of computed context-sensitive points-to facts, over a wide set of bench- marks and analyses, resulting in a 20% average speedup (max: 110%, median: 18%)

Defensive Points-To Analysis: Effective Soundness via Laziness

We present a defensive may-point-to analysis approach, which offers soundness even in the presence of arbitrary opaque code: all non-empty points-to sets computed are guaranteed to be over-approximations of the sets of values arising at run time. A key design tenet of the analysis is laziness: the analysis computes points-to relationships only for variables or objects that are guaranteed to never escape into opaque code. This means that the analysis misses some valid inferences, yet it also never wastes work to compute sets of values that are not "complete", i.e., that may be missing elements due to opaque code. Laziness enables great efficiency, allowing a highly precise points-to analysis (such as a 5-call-site-sensitive, flow-sensitive analysis). Despite its conservative nature, our analysis yields sound, actionable results for a large subset of the program code, achieving (under worst-case assumptions) 34-74% of the program coverage of an unsound state-of-the-art analysis for real-world programs

Efficient Reflection String Analysis via Graph Coloring

Static analyses for reflection and other dynamic language features have recently increased in number and advanced in sophistication. Most such analyses rely on a whole-program model of the flow of strings, through the stack and heap. We show that this global modeling of strings remains a major bottleneck of static analyses and propose a compact encoding, in order to battle unnecessary complexity. In our encoding, strings are maximally merged if they can never serve to differentiate class members in reflection operations. We formulate the problem as an instance of graph coloring and propose a fast polynomial-time algorithm that exploits the unique features of the setting (esp. large cliques, leading to hundreds of colors for realistic programs). The encoding is applied to two different frameworks for string-guided Java reflection analysis from past literature and leads to significant optimization (e.g., a ~2x reduction in the number of string-flow inferences), for a whole-program points-to analysis that uses strings

Hybrid Context-Sensitivity for Points-To Analysis

Context-sensitive points-to analysis is valuable for achieving high precision with good performance. The standard flavors of context-sensitivity are call-site-sensitivity (kCFA) and object-sensitivity. Combining both flavors of context-sensitivity increases precision but at an infeasibly high cost. We show that a selective combination of call-site-and object-sensitivity for Java points-to analysis is highly profitable. Namely, by keeping a combined context only when analyzing selected language features, we can closely approximate the precision of an analysis that keeps both contexts at all times. In terms of speed, the selective combination of both kinds of context not only vastly outperforms non-selective combinations but is also faster than a mere object-sensitive analysis. This result holds for a large array of analyses (e.g., 1-object-sensitive, 2-object-sensitive with a context-sensitive heap, type-sensitive) establishing a new set of performance/precision sweet spots

Hybrid Context Sensitivity for Poinst-To Analysis

Context-sensitive points-to analysis is valuable for achieving high precision with good performance. The standard flavors of context-sensitivity are call-site-sensitivity (kCFA) and object-sensitivity. Combining both flavors of context-sensitivity increases precision but at an infeasibly high cost. We show that a selective combination of call-site- and object-sensitivity for Java points-to analysis is highly profitable. Namely, by keeping a combined context only when analyzing selected language features, we can closely approximate the precision of an analysis that keeps both contexts at all times. In terms of speed, the selective combination of both kinds of context not only vastly outperforms non-selective combinations but is also faster than a mere object-sensitive analysis. This result holds for a large array of analyses (e.g., 1-object-sensitive, 2-object-sensitive with a context-sensitive heap, type-sensitive) establishing a new set of performance/precision sweet spots

Set-Based Pre-Processing for Points-To Analysis

We present set-based pre-analysis: a virtually universal optimization technique for flow-insensitive points-to analysis. Points-to analysis computes a static abstraction of how object values flow through a program’s variables. Set-based pre-analysis relies on the observation that much of this reasoning can take place at the set level rather than the value level. Computing constraints at the set level results in significant optimization opportunities: we can rewrite the input program into a simplified form with the same essential points-to properties. This rewrite results in removing both local variables and instructions, thus simplifying the subsequent value-based points-to computation. Effectively, set-based pre-analysis puts the program in a normal form optimized for points-to analysis. Compared to other techniques for off-line optimization of points-to analyses in the literature, the new elements of our approach are the ability to eliminate statements, and not just variables, as well as its modularity: set-based pre-analysis can be performed on the input just once, e. g., allowing the pre-optimization of libraries that are subsequently reused many times and for different analyses. In experiments with Java programs, set-based pre-analysis eliminates 30% of the program’s local variables and 30% or more of computed context-sensitive points-to facts, over a wide set of benchmarks and analyses, resulting in a similar to 20% average speedup (max: 110%, median: 18%)

Constraint Propagation as the Core of Local Search

Abstract. Constraint programming is a powerful paradigm for solving constraint satisfaction problems, using various techniques. Amongst them, local search is a prominent methodology, particularly for large instances. However, it lacks uniformity, as it includes many variations accompanied by complex data structures, that cannot be easily brought under the same “umbrella. ” In this work we embrace their wide diversity by adopting propagation algorithms. Our constraint based local search (CBLS) system provides declarative alternative tools to express search methods, by exploiting conflict-sets of constraints and variables. Their maintenance is straightforward as it does not employ queues, unlike the state of the art CBLS systems. Thus, the propagation complexity is kept linear in the number of changes required after each assignment. Experimental results illustrate the capabilities, not only of the already implemented methods, such as hill climbing, simulated annealing, etc., but also the robustness of the underlying propagation engine

An Efficient Data Structure for Must-Alias Analysis

A must-alias (or “definite-alias”) analysis computes sets of expressions that are guaranteed to be aliased at a given program point. The analysis has been shown to have significant practical impact, and it is actively used in popular research frameworks and commercial tools. We present a custom data structure that speeds up must-alias analysis by nearly two orders of magnitude (while computing identical results). The data structure achieves efficiency by encoding multiple alias sets in a single linked structure, and compactly representing the aliasing relations of arbitrarily long expressions. We explore the data structure’s performance in both an imperative and a declarative setting and contrast it extensively with prior techniques. With our approach, must-alias analysis can be performed efficiently, over large Java benchmarks, in under half a minute, making the analysis cost acceptable for most practical uses

Reliability and Validity of the Double Inclinometer Method for Assessing Thoracolumbar Joint Position Sense and Range of Movement in Patients with a Recent History of Low Back Pain

The study was aimed at examining the reliability of the Double Inclinometer (DI) method for the assessment of thoracolumbar Range of Movement (ROM) and Joint Position Sense (JPS) in patients with a recent history of Low Back Pain (LBP). Twenty patients with a history of LBP in the last three months participated. The thoracolumbar ROM and JPS were examined from a standing position by using both the DI and the tape measure method. The DI method was found to have moderate to good intra-rater (ICC = 0.68–0.79, SEM = 2.20–2.77°, SDD = 6.09–7.67°), moderate inter-rater (ICC = 0.59–0.62, SEM = 2.96–3.35°, SDD = 8.19–9.27°) and poor test-retest reliability (ICC = 0.13–0.17, SEM = 3.98–4.32°, SDD = 11.02–11.96°) for the assessment of thoracolumbar JPS. For the assessment of thoracolumbar ROM, the DI method was found to have good to excellent intra-rater (ICC = 0.88–0.94, SEM = 4.25–6.20°, SDD = 11.77–17.17°), excellent inter-rater (ICC = 0.90–0.91, SEM = 7.26–7.74°, SDD = 20.11–21.43°) and excellent test-retest reliability (ICC = 0.91–0.93, SEM = 6.03–6.87°, SDD = 16.70–19.02°). The concurrent validity of the DI method with the tape measure method was found to be very weak for the assessment of thoracolumbar JPS (r = 0.02, p = 0.93) and strong for the assessment of thoracolumbar ROM (r = 0.66, p = 0.001). The DI method seems to be a very reliable method for the assessment of thoracolumbar ROM in individuals with a recent history of LBP